home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / pcl_src.zoo / notes.txt < prev    next >
Encoding:
Text File  |  1992-09-09  |  10.3 KB  |  240 lines
  1.  
  2. These notes correspond to the "July 92 PCL (1b)" version of PCL.
  3.  
  4. Changes since July 92 PCL (beta) include some minor bug fixes and performance
  5. enhancements, along with new support for MCL 2.0 (thanks to Tom Morgan and
  6. the kind folks at Apple) and for CLISP (thanks to Bruno Haible).
  7.  
  8.   This version of PCL is much closer than previous versions of PCL
  9. to the metaobject protocol specified in "The Art of the Metaobject Protocol", 
  10. chapters 5 and 6, by Gregor Kiczales, Jim des Riveres, and Daniel G. Bobrow.
  11.  
  12. [Please read the file march-92-notes.text and may-day-notes.text also.
  13.   Most of those files still apply.]
  14.  
  15. Newly supported:
  16.  
  17. accessor-method-slot-definition
  18. no-next-method
  19. generic-function-argument-precedence-order
  20. reader-method-class
  21. writer-method-class
  22. (setf class-name)
  23.  
  24. defgeneric :method option
  25.  
  26. class-default-initargs, class-precedence-list, class-prototype,
  27.    and class-slots now signal errors when class is not finalized
  28.    (as specified in AMOP ch 6).
  29.  
  30. Improvements to slot-access
  31.   Optimization for slot-value of specialized parameter inside of defmethod.
  32.   Optimization for standard cases of slot-value everywhere else.
  33.  
  34. Additional support for structures
  35.   Redefines defstruct macro to give PCL access to all structure information
  36.   for structure classes in addition to calling the original lisp defstruct.
  37.  
  38. All AMOP generic-functions now exported.
  39.  
  40. -------------------------
  41. New gfs which obey AMOP ch 6, and some caveats:
  42.  
  43. documentation
  44.   Stored in all classes, pcl::documentation works as defined.
  45.  
  46. generic-function-declarations
  47.   Stored, but ignored.
  48.  
  49. make-method-lambda
  50. method-function
  51.   Compatible with AMOP, but will require additions to
  52.   compute-discriminating-function and compute-effective-method to
  53.   make fully useful.
  54.  
  55.   In July 92 PCL, method-function returns the documented AMOP
  56.   method-function specified by the lambda returned by make-method-lambda.
  57.   However, that method-function is not actually used in method function
  58.   dispatch.  Instead, PCL's make-method-lambda and expand-defmethod also
  59.   create an optimized method function (method-optimized-function) or
  60.   closure generator (method-closure-generator) that it actually uses for
  61.   method function caching and dispatch.  This is the same optimized
  62.   function whose lambda-list is the lambda-list of the method used in
  63.   previous versions of PCL.  There are two cases to worry about with this:
  64.  
  65.   1. The user specializes their own method on make-method-lambda without
  66.      redefining compute-discriminating-function or being careful to make
  67.      sure the method-optimized-function is set up properly (as done by the
  68.      standard make-method-lambda).  Expand-defmethod will detect this case
  69.      and create a method-optimized-function that calls the method-function
  70.      created by the new make-method-lambda with the parameters *of the
  71.      normal make-method-lambda*, i.e. (args methods).  This should work
  72.      for most cases, albeit slowly, but will fail if the user's modification
  73.      expects a different lambda list (as in the example of the AMOP, p. 209).
  74.  
  75.   2. The user specializes their own method on make-method-lambda, but also
  76.      specializes compute-discriminating-function to call method-function
  77.      directly.  This should work.
  78.  
  79.  
  80. -------------------------
  81. Functions which DO NOT obey AMOP:
  82.  
  83. compute-applicable-methods
  84. compute-applicable-methods-using-classes
  85.   Handles class-eq specializers without signalling an error.  
  86.   See march-92-notes.text
  87.  
  88. compute-discriminating-function
  89.   [the resulting function works differently different because 
  90.    compute-effective-method is different, and because make-method-lambda 
  91.    does not exist.]
  92.  
  93. compute-effective-method
  94.   Returns only one value.
  95.  
  96. -------------------------
  97. Miscellaneous optimizations:
  98.  
  99. Optimizations of slot-value of specialized parameter inside of
  100.   defmethod:
  101.  
  102.   1. Closure variables are now used instead of lookup permutation
  103.      vectors to store slot indices when the effective methods are
  104.      cached each set of parameter classes they're called on (which
  105.      is now all the time, using March 92's optimizations), saving an
  106.      aref per slot access.
  107.   2. The cached effective methods optimize slot-access based on the type
  108.      of slot indices for the cached parameters.  There are three cases:
  109.        (a) The most common case -- all specialized parameter slot
  110.         accesses within the defmethod are on :instance allocated slots
  111.         on standard instances without user-defined slot-value-using-class
  112.         methods.  In this case, the cached closure for the method
  113.         directly accesses the slot through an aref on the standard
  114.         instance, without having to call (typep x 'fixnum) or figure out
  115.         what type of instance it is.
  116.        (b) If one of the slot accesses is on a non-:instance allocated slot,
  117.         on a non-standard instance, or has a user-defined slot-value-using-class
  118.         method, and store-optimized-method-lambda-p is true for the
  119.         generic-function and method (the default defined in low.lisp being
  120.         *compile-slot-access-method-functions-at-runtime-p* is T), then the
  121.         method to be cached is compiled at runtime to optimize the slot accesses
  122.         from a stored version of the method-lambda.  The compiled method to be
  123.         cached directly codes in each slot access for the particular index
  124.         and the type of the instance.
  125.        (c). If there are non-standard slot accesses, as in case (b), but
  126.         store-optimized-method-lambda-p for the generic-function and method
  127.         is NIL, then the cached methods are not compiled at runtime.  Instead,
  128.         the cached effective method is similar to previous PCL's, i.e.
  129.         having to check the index and instance type for each slot access,
  130.         though looking up the cached index in a closure variable rather than
  131.         a permutation vector to save an aref.
  132.  
  133. Further optimizations of slot-value outside of defmethod or inside
  134.   of defmethod, but not of a specialized parameter:
  135.  
  136.   1. If no non-standard specialized methods have been defined on
  137.      slot-value-using-class, then slot-value directly looks up the
  138.      value of the slot without calling any generic-functions or functions.
  139.  
  140.   2. If non-standard specialized methods have been defined on
  141.      slot-value-using-class, then PCL arranges to call an automatically
  142.      created generic function that has one method: a reader method defined
  143.      on class slot-object (as in March 92 PCL).  This optimized generic-function
  144.      is now called whether or not the slot-name is constant.
  145.  
  146. Make-instance, shared-initialize, and allocate-instance speeded up by:
  147.   1. Implementing suggested instance slot-vector allocation optimization
  148.      of the AMOP that copies a slot-vector whose side-effect-free slots
  149.      are already initialized.
  150.   2. Using internal copy of slot-definitions (as structures) to speed
  151.      up time-intensive internal slot accesses (also speeds up
  152.      slot-value-using-class).
  153.   3. Usually assuming and assuring that all slot init-functions are compiled.
  154.  
  155. declarations of variable types throughout PCL where applicable.
  156.  
  157. avoids unnecessary class updates by lazier class finalization, giving
  158.   faster compiling and loading.
  159.  
  160.  
  161. -------------------------
  162. Miscellaneous optional optimizations (see global variables at beginning
  163. of file low.lisp for full options):
  164.  
  165. Variable *compile-all-method-functions-p* can be set to T, forcing all
  166.   method functions to be compiled and allowing method function dispatch
  167.   code to assume they are compiled.  Default is NIL.
  168.  
  169. Generic function store-method-function-p (generic-function method initargs)
  170.   can be specialized to return NIL if the (normally unused) documented
  171.   method-functions are not needed.  Saves some space and compile time.
  172.   Default returns T.  Variable *standard-store-method-function-p*, which
  173.   is what the default store-method-function-p method looks up, can be
  174.   set to NIL if it is known that documented method functions will never
  175.   be needed.
  176.  
  177. Generic function store-optimized-method-lambda-p (generic-function method initargs)
  178.   can be specialized to return NIL if it is not desireable to optimize
  179.   defmethod slot-accesses for non :instance allocated slots by compiling
  180.   the cached methods at runtime.  (This might be the case if your lisp's
  181.   compiler is slow, e.g. KCL, and each such method will only be called a
  182.   few times, so that the optimization isn't worth the added runtime compile
  183.   time.  Alternatively, *compile-slot-access-method-functions-at-runtime-p*
  184.   in low.lisp can be set to NIL to make this the default for all methods.
  185.  
  186. -------------------------
  187. Useful extensions to CLOS and AMOP:
  188.  
  189. boundp-method-class
  190. finalize-all-classes
  191.  
  192. trace-methods
  193.   Traces all individual methods of a generic-function (as per trace-method).
  194.  
  195. (setf standard-instance-access)
  196. (setf funcallable-standard-instance-access)
  197.   Functions to allow direct setting of instance slots
  198.   (as standard-instance-access and funcallable-standard-instance-access).
  199.  
  200. standard-instance-slot-value
  201. (setf standard-instance-slot-value)
  202. standard-instance-slot-boundp
  203. funcallable-standard-instance-slot-value
  204. (setf funcallable-standard-instance-slot-value)
  205. funcallable-standard-instance-slot-boundp
  206. structure-instance-slot-value
  207. (setf structure-instance-slot-value)
  208. structure-instance-slot-boundp
  209.   Macros for highly optimized slot access given type of instance
  210.   (analogous to standard-instance-access):
  211.  
  212. with-optimized-slots
  213.   Optimized version of with-slots with a couple of useful additions
  214.   to with-slots' functionality.
  215.  
  216. with-standard-instance-slots
  217.   Slightly faster version of with-optimized-slots for use when instance
  218.   is guaranteed to be a standard-instance.
  219.  
  220. this-method
  221.   Function locally defined within the body of methods to return the method
  222.   currently being executed.
  223.  
  224.  
  225. -------------------------
  226. Useful low-level extensions to PCL:
  227.  
  228. Class wrappers now have one unreserved field available for programmer use
  229.   (accessed by wrapper-unreserved-field).
  230.  
  231. Hooks built in to allow programmers to define their own USER-INSTANCE
  232.   low-level type of instances different from STD-INSTANCE, FSC-INSTANCE,
  233.   STRUCTURE-INSTANCE, or BUILT-IN-INSTANCE (see file user-instances.lisp
  234.   as an example of their use to save space over standard instances).
  235.  
  236.  
  237. -- Trent Lange
  238.    e-mail:  lange@cs.ucla.edu
  239.  
  240.